\documentclass{article}

\usepackage[top=2.5cm, bottom=2.5cm, left=2cm, right=2cm]{geometry}
\usepackage{fancyhdr}
\lhead{\bsc{Programmation Orientee Objet}}
\rhead{\bsc{TD3}}
\renewcommand{\headrulewidth}{1px}
\lfoot{ \bsc{Enseirb-Matmeca}}
\rfoot{ \bsc{Informatique - I2}}
\renewcommand{\footrulewidth}{1px}
\pagestyle{fancy}
\usepackage{wrapfig}
\usepackage{multicol}
\usepackage{textcomp}
\usepackage[T1]{fontenc}
\usepackage{setspace}


%\usepackage[vlined,lined,boxed,french,longend]{algorithm2e}

\usepackage{graphicx}
\usepackage[french]{babel}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{mathrsfs}
\usepackage{xcolor}
\usepackage[utf8]{inputenc}
%%%%%%%%%%%%%%%% Variables %%%%%%%%%%%%%%%%
\def\projet{2}
\def\titre{Lot 1: Réalisation du périmètre fonctionnel \\
  --------------------- \\Les classes Autobus et PassagerStandard}
\def\groupe{2}
\def\equipe{piyovimoad}
\def\responsible{ppocquetduhautjusse}
\def\tandemi{avilliermet, vpomier}
\def\tandemii{ydubernet, mmegzari}

\begin{document}
%%%%%%%%%%%%%%%% Header %%%%%%%%%%%%%%%%
\noindent\begin{minipage}{\textwidth}
\vskip 0mm
\noindent
    { \begin{tabular}{p{7.5cm}}
        {\bfseries \sffamily
          Rapport du TD n°3 de l'équipe \equipe}
        \begin{center}{\itshape \titre}\end{center}
    \end{tabular}}
    \hfill 
    \fbox{\begin{tabular}{l}
        {~\hfill \bfseries \sffamily 16/10/12 \hspace{1.5mm} \hfill~} \\[2mm] 
        Coordinateur : \responsible \\
        Tandem1 : \tandemi \\
        Tandem2 : \tandemii
    \end{tabular}}
    \vskip 4mm ~

    \parbox{\textwidth}{\small \textit{Travail restant à  la fin de la séance~:}

Il restait la fin de la partie 2 (à partir de 2-1 question 5), ainsi que toute la partie 3.

 }
    \vskip 1mm ~
\end{minipage}


%%%%%%%%%%%%%%%% Main part %%%%%%%%%%%%%%%%

\section{Analyse des dépendances entre classes}

Avant de commencer tout travail il convient de  préparer le répertoire de travail. Nous avons ainsi créé un répertoire par classe pour les classes \texttt{PassagerStandart} et \texttt{Autobus}. Dans chacun, nous avons gardé uniquement les classes nécessaires au développement.

Dans cette partie, la programmation  est séparée entre les tandems du groupe. Le travail devient alors particulier, les deux tandems ont en effet besoin de l'autre partie pour que la leur fonctionne.

Des classes faussaires ont ainsi été nécessaires ici. Ces classes permettent à chaque tandem d'être indépendant de l'autre tandem pour leur code.


Un faussaire est une classe qui permet de simuler un comportement pour pouvoir tester une autre classe, c'est donc très utile pour les tests car un tandem n'est pas dépendant dans son développement de l'autre tandem. Un faussaire  est minimal dans son contenu, ca ne doit pas être un recodage de la classe.
Il permet de tracer les appels, avec une chaine de caractères qui trace les appels.
\\


On crée la classe minimale d'autobus (\textt{Autobus}) et sa classe de test \texttt{TestAutobus}.

Pour la modification de la classe \texttt{LancerTest} on rajoute juste l'instanciation d'une classe \texttt{testAutobus} (\texttt {TestAutobus testBus = new TestAutobus();}) et on fait appel à la méthode \texttt{testBus.lancerTestAutobus();}

Dans la classe de test, on peut dorénavant instancier une classe faussaire de \texttt{PassagerStandard} en utilisant des \texttt{static final byte} instanciés dans \texttt{PassagerStandard.java} pour changer l'état d'un passager standard (dehors, assis ou debout).




\section{Classes PassagerStandard et Autobus}
\subsection{Préparation du répertoire de travail}

A ce stade, les classes \texttt{PassagerStandard} et \texttt{Autobus} sont public, elles sont donc accessibles à l'extérieur du paquetage \texttt{tec}.

La classe \texttt{EtatPassager} représente l'état d'un passager dans un autobus. Il y a un état à l'exterieur du transport (DEHORS) et deux états à l'intérieur (ASSIS, DEBOUT).
 
\subsection{Développement et tests}
Les instances de la classe EtatPassager sont des objets constants.

Si cette classe ne construisait pas d'objets constants, il faudrait une instance \texttt{EtatPassager} par instance \texttt{PassagerStandart}, un état serait alors associé à un passager et cela nécéssiterait de déclarer trois états par passager.

Alors qu'avec des objets constants on se limite à trois instances \texttt{EtatPassager} ce qui correspond aux nombres d'états possibles.

\\
 Pour la construction des faussaires on utilise des \texttt{bytes} qui décrivent l'état de notre faussaire. Cet entier doit être accessible. 
Nos faussaires possèdent 4 bytes pour \textt{Autobus} et 3 pour \texttt{EtatPassager} :
\vspace{0.5cm}

\texttt{PLEIN VIDE AASSIS ADEBOUT} pour \texttt{Autobus}

\texttt{DEBOUT ASSIS DEHORS} pour \texttt{EtatPassager}

\vspace{0.5cm}

Les passagers sont représentés par une jauge, d'où l'interêt des tests.
Afin de développer cette partie, nous avons fait attention d'écrire d'abord le test principal, puis de compléter le code existant pour satisfaire à ce test.


La démarche demandée est d'écrire le test d'un traitement puis d'écrire son code (Développement Dirigé par les Tests). Au début ce concept a été difficile à assimiler. Nous avons donc décidé de suivre l'ordre d'écriture des traitements proposés par le sujet.
\\

Malheureusement pour la partie \texttt{Autobus} le tandem est parti sur une mauvaise interprétation des spécifications du TD0 et notament de l'utilisation de \texttt{JaugeNaturel}. Il a donc fallu recommener tout le développement, ce qui a impliqué une perte de temps importante et impacté le déroulement des tests de recette.

Cependant, nous pensons que le mécanisme du TDD a bien été assimilé. Pour chaque traitement voici notre méthode:
\begin{itemize}
\item
Ecriture du test avec instanciation du ou des faussaires nécessaire(s) et d'un autobus dans un premier temps. Ensuite nous mettons les \texttt{assert} conformément à la doc. On compile/exécute une fois pour vérifier qu'il n'y a pas d'erreurs. Comme les traitements ne sont pas encore écrits, les \texttt{assert} renvoient \texttt{faux}.
\item
Ecriture du traitement correspondant au test et correction des \texttt{assert}.
\item
Recompilation/exécution pour vérifier que notre traitement a été codé correctement. 
\end{itemize}
\vspace{0.5cm}
Cas particulier du constructeur : il nous a été difficle d'identifier les instances dont on aurait besoin dans le constructeur d'autobus. Grace à la doc du TD0 et des tests demandés, on a conclu qu'on aurait besoin de deux jauges : une pour les places assises, une pour les places debouts. Ensuite, un entier correspondant aux arrêts du bus et un tableau de \texttt{PassagerStandard} de la taille correspondant à la somme des places assises et des places debout.

\\
Gestion du faussaire: il nous a également été difficile au début de bien cerner la manière d'utiliser notre faussaire  \texttt{PassagerStandard} et dans quelle mesure ont devait modifier \texttt{PassagerStandard.java} pour respecter le concept de faussaire. 

Finalement on a conclu qu'il suffisait d'utiliser des bytes pour simuler les états des passagers. Enfin, il nous a fallu utiliser la classe \texttt{Message} pour pouvoir tracer les appels au méthodes avec nos faussaires, son intégration fut simple, nous nous sommes appuyés sur l'exemple de \texttt{PorteCharnière}.


Le développement a été similaire pour la classe \texttt{PassagerStandard}.



\section{Le test de recette}
\subsection{Séparer les doublons}
Dans cette partie il faut créer plusieurs répertoires contenant le travail de chaque tandem afin d'effectuer les tests spécifiques aux classes faussaires.



\subsection{Fusionner les répertoires de travail}
Notre nouvelle arborescence nous oblige à avoir des lignes d'exécutions et de compilation un peu plus détaillées.


La commande pour compiler toutes les classes du répertoire \texttt{src/tec} depuis le répertoire \texttt{build} est:

\vspace{0.5cm}
\texttt{javac -d build src/tec/*.java}
\vspace{0.5cm}

 L'option \texttt{-d} permet de spécifer au compilateur un dossier différent dans lequel mettre les fichiers .class créés alors que par défaut ils seront mis dans le dossier courant. Cette option crée, si nécessaire, dans le dossier de destination,
l'arborescence des différents packages créés. 

\\
La commande pour compiler toutes les classes du répertoire \texttt{srcTestAutobus} dans le répertoire \texttt{buildTestAutobus} utilise l'option \texttt{-cp}. Voici la commande détaillée :

\vspace{0.5cm}
\texttt{javac -d  buildTestAutobus -classpath build/ srcTestAutobus/*.java }
\vspace{0.5cm}

De même pour \texttt{srcTestPassager} et \texttt{buildTestPassager} :

\vspace{0.2cm}
\texttt{javac -d  buildTestPassager -cp build/ srcTestPassager/*.java }
\vspace{0.5cm}


La commande pour exécuter la classe \texttt{tec.LancerTests} du répertoire \texttt{buildTestPassager} est:

\texttt{java  -classpath buildTestPassager/ :build/ -ea tec.LancerTests}
\vspace{0.5cm}

L'option \texttt{-ea} permet d'activer les assertions et donc nos tests.


De même pour exécuter à partir du répertoire \texttt{buildTestAutobus}


\texttt{java -classpath buildTestAutobus/:build/ -ea tec.LancerTests}
\vspace{0.5cm}


L'ordre des repertoires d'exécution est important. Il faut commencer par le répertoire \texttt{buildTestPassager} pour que la machine virtuelle cherche la version faussaire de la classe \texttt{Autobus} et non la version normale. Pareil lorsqu'on execute \texttt{TestAutobus}.
\texttt{java -classpath buildTestAutobus/:build/ -ea tec.LancerTests},

 on aura besoin du fichier \texttt{Autobus.class} qui se trouve dans \texttt{buildTestPassager} et non de celui qui se trouve dans build.


\subsection{Vérification du test de recette}
Pour compiler la classe \texttt{Simple} dans le répertoire \texttt{build} la commande est:


\texttt{javac -d build -classpath build/ recette/Simple.java}

\vspace{0.5cm}
Pour exécuter cette classe la commande est:

\texttt{java -classpath build/  Simple}
\\

On se basant sur la première version de \texttt{Simple.java}, à l'execution on obtenait un affichage qui correspondait pas au résultat voulu. Le problème provenait de :
\begin{itemize}
\item Le code de la classe Simple : A l'affichage des messages de déboguage, on print les adresses des instances et non pas des chaînes de caractères.
\item Le code des classes PassagerStandard, Autobus, JaugeNaturel et EtatPassager : Les méthodes toString(); qui permettaient de renvoyer des chaînes de caractères et pouvaient ainsi servirent à décrire les etats des instances des différentes classes, soit n'étaient pas redéfinis (c'était le cas pour PassagerStandard et Autobus), soit elles étaient mal redéfinis.
\end{itemize}
Donc pour avoir le bon affichage, il a fallu modifier le code de la classe Simple en faisant appel aux méthodes \texttt{toString()} sur les instances de \textt{PassagerStandard} et \textt{Autobus} de cette manière : \\
\emph{System.out.println(serinity.toString()}.

Le fait que la méthode soit redéfinie dans toutes les classes cités auparavant permet de l'appliquer au type d'instance correspondant.
\\
Ensuite il a fallu redéfinir la méthode \texttt{toString()} dans les classes \textt{PassagerStandard} et \texttt{Autobus} et la corriger dans les deux autres classes vu qu'il existe un lien \emph{a-un} entre ces dernières et les deux autres classes, pour ainsi renvoyer le bon état de l'instance.   
 
\subsection{Bouter vos neurones}
Il faut ensuite archiver le package \texttt{tec}  car le nom de notre package est \texttt{tec}, et non pas \texttt{build.tec}.
Donc lors de la mise en marche de la machine virtuelle, elle cherchera comme dossier racine le dossier \texttt{tec}. Or, si le dossier racine est le dossier \texttt{build}, il y aura une erreur car elle ne trouvera pas de dossier \texttt{tec} à la racine.

\vspace{0.5cm}

La commande d'archivage est:

\texttt{jar cvf montec.jar tec/*.class}

\vspace{0.5cm}
La commande de compilation de la classe \texttt{Simple} (le fichier compilé reste dans le répertoire courant) est :

\texttt{javac -cp montec.jar Simple.java}

\vspace{0.5cm}
La commande qui permet d’exécuter la classe \texttt{Simple} est :

\texttt{java -cp ./:montec.jar Simple}

\vspace{0.5cm}
Pour tester la classe \texttt{PassagerStandard} depuis le répertoire recette, il faut entrer la commande suivante :

\texttt{java -cp ../../buildTestPassager/:montec.jar -ea tec.LancerTests}

\vspace{0.5cm}
Pour tester la classe \texttt{Autobus} depuis le répertoire recette, il faut entrer la commande suivante :

\texttt{java -cp ../../buildTestAutobus/:montec.jar -ea tec.LancerTests}


\section{Conclusion}

 Le démarrage lors de la séance a été assez long, nous avons d'abord essayé de comprendre nos erreurs du TD précédant avant de nous pencher sur celui là.  


Ce TD a permis de nous mettre plus à l'aise avec le langage JAVA.  Il nous aura montré ce que sont les faussaires et leur utilisation. Il nous aura de plus montré une démarche de développement orientée par les tests. Enfin, ce TD nous aura permis de réviser les différentes options pour la compilation et l'exécution de fichiers.


\end{document}
